home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / BBCodeParser.php next >
PHP Script  |  2004-03-24  |  23KB  |  708 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2003 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author: Stijn de Reede <sjr@gmx.co.uk>                               |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: BBCodeParser.php,v 1.6 2004/01/18 23:26:16 sjr Exp $
  20. //
  21.  
  22. /**
  23. * @package  HTML_BBCodeParser
  24. * @author   Stijn de Reede  <sjr@gmx.co.uk>
  25. *
  26. *
  27. * This is a parser to replace UBB style tags with their html equivalents. It
  28. * does not simply do some regex calls, but is complete stack based
  29. * parse engine. This ensures that all tags are properly nested, if not,
  30. * extra tags are added to maintain the nesting. This parser should only produce
  31. * xhtml 1.0 compliant code. All tags are validated and so are all their attributes.
  32. * It should be easy to extend this parser with your own tags, see the _definedTags
  33. * format description below.
  34. *
  35. *
  36. * Usage:
  37. * $parser = new HTML_BBCodeParser();
  38. * $parser->setText('normal [b]bold[/b] and normal again');
  39. * $parser->parse();
  40. * echo $parser->getParsed();
  41. * or:
  42. * $parser = new HTML_BBCodeParser();
  43. * echo $parser->qparse('normal [b]bold[/b] and normal again');
  44. * or:
  45. * echo HTML_BBCodeParser::staticQparse('normal [b]bold[/b] and normal again');
  46. *
  47. *
  48. * Setting the options from the ini file:
  49. * $config = parse_ini_file('BBCodeParser.ini', true);
  50. * $options = &PEAR::getStaticProperty('HTML_BBCodeParser', '_options');
  51. * $options = $config['HTML_BBCodeParser'];
  52. * unset($options);
  53. *
  54. *
  55. * The _definedTags variables should be in this format:
  56. * array('tag'                                // the actual tag used
  57. *           => array('htmlopen'  => 'open',  // the opening tag in html
  58. *                    'htmlclose' => 'close', // the closing tag in html,
  59. *                                               can be set to an empty string
  60. *                                               if no closing tag is present
  61. *                                               in html (like <img>)
  62. *                    'allowed'   => 'allow', // tags that are allowed inside
  63. *                                               this tag. Values can be all
  64. *                                               or none, or either of these
  65. *                                               two, followed by a ^ and then
  66. *                                               followed by a comma seperated
  67. *                                               list of exceptions on this
  68. *                    'attributes' => array() // an associative array containing
  69. *                                               the tag attributes and their
  70. *                                               printf() html equivalents, to
  71. *                                               which the first argument is
  72. *                                               the value, and the second is
  73. *                                               the quote. Default would be
  74. *                                               something like this:
  75. *                                               'attr' => 'attr=%2$s%1$s%2$s'
  76. *                   ),
  77. *       'etc'
  78. *           => (...)
  79. *       )
  80. *
  81. *
  82. */
  83.  
  84.  
  85. require_once ('PEAR.php');
  86.  
  87.  
  88.  
  89.  
  90. class HTML_BBCodeParser
  91. {
  92.  
  93.     /**
  94.     * An array of tags parsed by the engine, should be overwritten by filters
  95.     *
  96.     * @access   private
  97.     * @var      array
  98.     */
  99.     var $_definedTags  = array();
  100.  
  101.     /**
  102.     * A string containing the input
  103.     *
  104.     * @access   private
  105.     * @var      string
  106.     */
  107.     var $_text          = '';
  108.  
  109.     /**
  110.     * A string containing the preparsed input
  111.     *
  112.     * @access   private
  113.     * @var      string
  114.     */
  115.     var $_preparsed     = '';
  116.  
  117.     /**
  118.     * An array tags and texts build from the input text
  119.     *
  120.     * @access   private
  121.     * @var      array
  122.     */
  123.     var $_tagArray      = array();
  124.  
  125.     /**
  126.     * A string containing the parsed version of the text
  127.     *
  128.     * @access   private
  129.     * @var      string
  130.     */
  131.     var $_parsed        = '';
  132.  
  133.     /**
  134.     * An array of options, filled by an ini file or through the contructor
  135.     *
  136.     * @access   private
  137.     * @var      array
  138.     */
  139.     var $_options = array(  'quotestyle'    => 'single',
  140.                             'quotewhat'     => 'all',
  141.                             'open'          => '[',
  142.                             'close'         => ']',
  143.                             'xmlclose'      => true,
  144.                             'filters'       => 'Basic'
  145.                          );
  146.  
  147.     /**
  148.     * An array of filters used for parsing
  149.     *
  150.     * @access   private
  151.     * @var      array
  152.     */
  153.     var $_filters       = array();
  154.  
  155.  
  156.  
  157.  
  158.     /**
  159.     * Constructor, initialises the options and filters
  160.     *
  161.     * Sets the private variable _options with base options defined with
  162.     * &PEAR::getStaticProperty(), overwriting them with (if present)
  163.     * the argument to this method.
  164.     * Then it sets the extra options to properly escape the tag
  165.     * characters in preg_replace() etc. The set options are
  166.     * then stored back with &PEAR::getStaticProperty(), so that the filter
  167.     * classes can use them.
  168.     * All the filters in the options are initialised and their defined tags
  169.     * are copied into the private variable _definedTags.
  170.     *
  171.     * @param    array           options to use, can be left out
  172.     * @return   none
  173.     * @access   public
  174.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  175.     */
  176.     function HTML_BBCodeParser($options = array())
  177.     {
  178.  
  179.         /* set the already set options */
  180.         $baseoptions = &PEAR::getStaticProperty('HTML_BBCodeParser', '_options');
  181.         if (is_array($baseoptions)) {
  182.             foreach ($baseoptions as  $k => $v)  {
  183.                 $this->_options[$k] = $v;
  184.             }
  185.         }
  186.  
  187.         /* set the options passed as an argument */
  188.         foreach ($options as $k => $v )  {
  189.            $this->_options[$k] = $v;
  190.         }
  191.  
  192.         /* add escape open and close chars to the options for preg escaping */
  193.         $preg_escape = '\^$.[]|()?*+{}';
  194.         if (strstr($preg_escape, $this->_options['open'])) {
  195.             $this->_options['open_esc'] = "\\".$this->_options['open'];
  196.         } else {
  197.             $this->_options['open_esc'] = $this->_options['open'];
  198.         }
  199.         if (strstr($preg_escape, $this->_options['close'])) {
  200.             $this->_options['close_esc'] = "\\".$this->_options['close'];
  201.         } else {
  202.             $this->_options['close_esc'] = $this->_options['close'];
  203.         }
  204.  
  205.         /* set the options back so that child classes can use them */
  206.         $baseoptions = $this->_options;
  207.         unset($baseoptions);
  208.  
  209.         /* return if this is a subclass */
  210.         if (is_subclass_of($this, 'HTML_BBCodeParser')) return;
  211.  
  212.         /* extract the definedTags from subclasses */
  213.         $filters = explode(',', $this->_options['filters']);
  214.         foreach ($filters as $filter) {
  215.             $class = 'HTML_BBCodeParser_Filter_'.$filter;
  216.             @include_once ('HTML/BBCodeParser/Filter/'.$filter.'.php');
  217.             if (!class_exists($class)) {
  218.                 PEAR::raiseError("Failed to load filter $filter", null, PEAR_ERROR_DIE);
  219.             }
  220.             $this->_filters[$filter] = new $class;
  221.             $this->_definedTags = array_merge($this->_definedTags, $this->_filters[$filter]->_definedTags);
  222.         }
  223.     }
  224.  
  225.  
  226.  
  227.  
  228.     /**
  229.     * Executes statements before the actual array building starts
  230.     *
  231.     * This method should be overwritten in a filter if you want to do
  232.     * something before the parsing process starts. This can be useful to
  233.     * allow certain short alternative tags which then can be converted into
  234.     * proper tags with preg_replace() calls.
  235.     * The main class walks through all the filters and and calls this
  236.     * method. The filters should modify their private $_preparsed
  237.     * variable, with input from $_text.
  238.     *
  239.     * @return   none
  240.     * @access   private
  241.     * @see      $_text
  242.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  243.     */
  244.     function _preparse()
  245.     {
  246.         /* default: assign _text to _preparsed, to be overwritten by filters */
  247.         $this->_preparsed = $this->_text;
  248.  
  249.         /* return if this is a subclass */
  250.         if (is_subclass_of($this, 'HTML_BBCodeParser')) return;
  251.  
  252.         /* walk through the filters and execute _preparse */
  253.         foreach ($this->_filters as $filter) {
  254.             $filter->setText($this->_preparsed);
  255.             $filter->_preparse();
  256.             $this->_preparsed = $filter->getPreparsed();
  257.         }
  258.     }
  259.  
  260.  
  261.  
  262.  
  263.     /**
  264.     * Builds the tag array from the input string $_text
  265.     *
  266.     * An array consisting of tag and text elements is contructed from the
  267.     * $_preparsed variable. The method uses _buildTag() to check if a tag is
  268.     * valid and to build the actual tag to be added to the tag array.
  269.     *
  270.     * TODO: - rewrite whole method, as this one is old and probably slow
  271.     *       - see if a recursive method would be better than an iterative one
  272.     *
  273.     * @return   none
  274.     * @access   private
  275.     * @see      _buildTag()
  276.     * @see      $_text
  277.     * @see      $_tagArray
  278.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  279.     */
  280.     function _buildTagArray()
  281.     {
  282.         $this->_tagArray = array();
  283.         $str = $this->_preparsed;
  284.         $strPos = 0;
  285.         $strLength = strlen($str);
  286.  
  287.         while ( ($strPos < $strLength) ) {
  288.             $tag = array();
  289.             $openPos = strpos($str, $this->_options['open'], $strPos);
  290.             if ($openPos === false) {
  291.                 $openPos = $strLength;
  292.                 $nextOpenPos = $strLength;
  293.             }
  294.             if ($openPos + 1 > $strLength) {
  295.                 $nextOpenPos = $strLength;
  296.             } else {
  297.                 $nextOpenPos = strpos($str, $this->_options['open'], $openPos + 1);
  298.                 if ($nextOpenPos === false) {
  299.                     $nextOpenPos = $strLength;
  300.                 }
  301.             }
  302.             $closePos = strpos($str, $this->_options['close'], $strPos);
  303.             if ($closePos === false) {
  304.                 $closePos = $strLength + 1;
  305.             }
  306.  
  307.             if ( $openPos == $strPos ) {
  308.                 if ( ($nextOpenPos < $closePos) ) {
  309.                     /* new open tag before closing tag: treat as text */
  310.                     $newPos = $nextOpenPos;
  311.                     $tag['text'] = substr($str, $strPos, $nextOpenPos - $strPos);
  312.                     $tag['type'] = 0;
  313.                 } else {
  314.                     /* possible valid tag */
  315.                     $newPos = $closePos + 1;
  316.                     $newTag = $this->_buildTag(substr($str, $strPos, $closePos - $strPos + 1));
  317.                     if ( ($newTag !== false) ) {
  318.                         $tag = $newTag;
  319.                     } else {
  320.                     /* no valid tag after all */
  321.                         $tag['text'] = substr($str, $strPos, $closePos - $strPos + 1);
  322.                         $tag['type'] = 0;
  323.                     }
  324.                 }
  325.             } else {
  326.                 /* just text */
  327.                 $newPos = $openPos;
  328.                 $tag['text'] = substr($str, $strPos, $openPos - $strPos);
  329.                 $tag['type'] = 0;
  330.             }
  331.  
  332.             /* join 2 following text elements */
  333.             if ($tag['type'] === 0 && isset($prev) && $prev['type'] === 0) {
  334.                 $tag['text'] = $prev['text'].$tag['text'];
  335.                 array_pop($this->_tagArray);
  336.             }
  337.  
  338.             $this->_tagArray[] = $tag;
  339.             $prev = $tag;
  340.             $strPos = $newPos;
  341.         }
  342.     }
  343.  
  344.  
  345.  
  346.  
  347.     /**
  348.     * Builds a tag from the input string
  349.     *
  350.     * This method builds a tag array based on the string it got as an
  351.     * argument. If the tag is invalid, <false> is returned. The tag
  352.     * attributes are extracted from the string and stored in the tag
  353.     * array as an associative array.
  354.     *
  355.     * @param    string          string to build tag from
  356.     * @return   array           tag in array format
  357.     * @access   private
  358.     * @see      _buildTagArray()
  359.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  360.     */
  361.     function _buildTag($str)
  362.     {
  363.         $tag = array('text' => $str, 'attributes' => array());
  364.  
  365.         if (substr($str, 1, 1) == '/') {        /* closing tag */
  366.  
  367.             $tag['tag'] = substr($str, 2, strlen($str) - 3);
  368.             if ( (in_array($tag['tag'], array_keys($this->_definedTags)) == false) ) {
  369.                 return false;                   /* nope, it's not valid */
  370.             } else {
  371.                 $tag['type'] = 2;
  372.                 return $tag;
  373.             }
  374.         } else {                                /* opening tag */
  375.  
  376.             $tag['type'] = 1;
  377.             if ( (strpos($str, ' ') == true) && (strpos($str, '=') == false) ) {
  378.                 return false;                   /* nope, it's not valid */
  379.             }
  380.  
  381.             /* tnx to Onno for the regex
  382.                split the tag with arguments and all */
  383.             $oe = $this->_options['open_esc'];
  384.             $ce = $this->_options['close_esc'];
  385.             if (preg_match("!$oe([a-z]+)[^$ce]*$ce!i", $str, $tagArray) == 0) {
  386.                 return false;
  387.             }
  388.             $tag['tag'] = $tagArray[1];
  389.             if ( (in_array($tag['tag'], array_keys($this->_definedTags)) == false) ) {
  390.                 return false;                   /* nope, it's not valid */
  391.             }
  392.  
  393.             /* tnx to Onno for the regex
  394.                validate the arguments */
  395.             preg_match_all("![\s$oe]([a-z]+)=([^\s$ce]+)(?=[\s$ce])!i", $str, $attributeArray, PREG_SET_ORDER);
  396.             foreach ($attributeArray as $attribute) {
  397.                 if ( (in_array($attribute[1], array_keys($this->_definedTags[$tag['tag']]['attributes'])) == true) ) {
  398.                     $tag['attributes'][$attribute[1]] = $attribute[2];
  399.                 }
  400.             }
  401.             return $tag;
  402.         }
  403.     }
  404.  
  405.  
  406.  
  407.  
  408.     /**
  409.     * Validates the tag array, regarding the allowed tags
  410.     *
  411.     * While looping through the tag array, two following text tags are
  412.     * joined, and it is checked that the tag is allowed inside the
  413.     * last opened tag.
  414.     * By remembering what tags have been opened it is checked that
  415.     * there is correct (xml compliant) nesting.
  416.     * In the end all still opened tags are closed.
  417.     *
  418.     * @return   none
  419.     * @access   private
  420.     * @see      _isAllowed()
  421.     * @see      $_tagArray
  422.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  423.     */
  424.     function _validateTagArray()
  425.     {
  426.         $newTagArray = array();
  427.         $openTags = array();
  428.         foreach ($this->_tagArray as $tag) {
  429.             $prevTag = end($newTagArray);
  430.             switch ($tag['type']) {
  431.             case 0:
  432.                 if ($prevTag['type'] === 0) {
  433.                     $tag['text'] = $prevTag['text'].$tag['text'];
  434.                     array_pop($newTagArray);
  435.                 }
  436.                 $newTagArray[] = $tag;
  437.                 break;
  438.  
  439.             case 1:
  440.                 if ($this->_isAllowed(end($openTags), $tag['tag']) == false) {
  441.                     $tag['type'] = 0;
  442.                     if ($prevTag['type'] === 0) {
  443.                         $tag['text'] = $prevTag['text'].$tag['text'];
  444.                         array_pop($newTagArray);
  445.                     }
  446.                 } else {
  447.                     $openTags[] = $tag['tag'];
  448.                 }
  449.                 $newTagArray[] = $tag;
  450.                 break;
  451.  
  452.             case 2:
  453.                 if ( ($this->_isAllowed(end($openTags), $tag['tag']) == true) || ($tag['tag'] == end($openTags)) ) {
  454.                     if (in_array($tag['tag'], $openTags)) {
  455.                         $tmpOpenTags = array();
  456.                         while (end($openTags) != $tag['tag']) {
  457.                             $newTagArray[] = $this->_buildTag('[/'.end($openTags).']');
  458.                             $tmpOpenTags[] = end($openTags);
  459.                             array_pop($openTags);
  460.                         }
  461.                         $newTagArray[] = $tag;
  462.                         array_pop($openTags);
  463.                         while (end($tmpOpenTags)) {
  464.                             $tmpTag = $this->_buildTag('['.end($tmpOpenTags).']');
  465.                             $newTagArray[] = $tmpTag;
  466.                             $openTags[] = $tmpTag['tag'];
  467.                             array_pop($tmpOpenTags);
  468.                         }
  469.                     }
  470.                 } else {
  471.                     $tag['type'] = 0;
  472.                     if ($prevTag['type'] === 0) {
  473.                         $tag['text'] = $prevTag['text'].$tag['text'];
  474.                         array_pop($newTagArray);
  475.                     }
  476.                     $newTagArray[] = $tag;
  477.                 }
  478.                 break;
  479.             }
  480.         }
  481.         while (end($openTags)) {
  482.             $newTagArray[] = $this->_buildTag('[/'.end($openTags).']');
  483.             array_pop($openTags);
  484.         }
  485.         $this->_tagArray = $newTagArray;
  486.     }
  487.  
  488.  
  489.  
  490.  
  491.     /**
  492.     * Checks to see if a tag is allowed inside another tag
  493.     *
  494.     * The allowed tags are extracted from the private _definedTags array.
  495.     *
  496.     * @param    array           tag that is on the outside
  497.     * @param    array           tag that is on the inside
  498.     * @return   boolean         return true if the tag is allowed, false
  499.     *                           otherwise
  500.     * @access   private
  501.     * @see      _validateTagArray()
  502.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  503.     */
  504.     function _isAllowed($out, $in)
  505.     {
  506.         if (!$out)                                          return true;
  507.         if ($this->_definedTags[$out]['allowed'] == 'all')  return true;
  508.         if ($this->_definedTags[$out]['allowed'] == 'none') return false;
  509.  
  510.         $ar = explode('^', $this->_definedTags[$out]['allowed']);
  511.         $tags = explode(',', $ar[1]);
  512.         if ($ar[0] == 'none' && in_array($in, $tags))       return true;
  513.         if ($ar[0] == 'all'  && in_array($in, $tags))       return false;
  514.         return false;
  515.     }
  516.  
  517.  
  518.  
  519.  
  520.     /**
  521.     * Builds a parsed string based on the tag array
  522.     *
  523.     * The correct html and atribute values are extracted from the private
  524.     * _definedTags array.
  525.     *
  526.     * @return   none
  527.     * @access   private
  528.     * @see      $_tagArray
  529.     * @see      $_parsed
  530.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  531.     */
  532.     function _buildParsedString()
  533.     {
  534.         $this->_parsed = '';
  535.         foreach ($this->_tagArray as $tag) {
  536.             switch ($tag['type']) {
  537.  
  538.             /* just text */
  539.             case 0:
  540.                 $this->_parsed .= $tag['text'];
  541.                 break;
  542.  
  543.             /* opening tag */
  544.             case 1:
  545.                 $this->_parsed .= '<'.$this->_definedTags[$tag['tag']]['htmlopen'];
  546.                 if ($this->_options['quotestyle'] == 'single') $q = "'";
  547.                 if ($this->_options['quotestyle'] == 'double') $q = '"';
  548.                 foreach ($tag['attributes'] as $a => $v) {
  549.                     if (    ($this->_options['quotewhat'] == 'nothing') ||
  550.                             ($this->_options['quotewhat'] == 'strings') && (is_numeric($v)) ) {
  551.                         $this->_parsed .= ' '.sprintf($this->_definedTags[$tag['tag']]['attributes'][$a], $v, '');
  552.                     } else {
  553.                         $this->_parsed .= ' '.sprintf($this->_definedTags[$tag['tag']]['attributes'][$a], $v, $q);
  554.                     }
  555.                 }
  556.                 if ($this->_definedTags[$tag['tag']]['htmlclose'] == '' && $this->_options['xmlclose']) {
  557.                     $this->_parsed .= ' /';
  558.                 }
  559.                 $this->_parsed .= '>';
  560.                 break;
  561.  
  562.             /* closing tag */
  563.             case 2:
  564.                 if ($this->_definedTags[$tag['tag']]['htmlclose'] != '') {
  565.                     $this->_parsed .= '</'.$this->_definedTags[$tag['tag']]['htmlclose'].'>';
  566.                 }
  567.                 break;
  568.             }
  569.         }
  570.  
  571.     }
  572.  
  573.  
  574.  
  575.  
  576.     /**
  577.     * Sets text in the object to be parsed
  578.     *
  579.     * @param    string          the text to set in the object
  580.     * @return   none
  581.     * @access   public
  582.     * @see      getText()
  583.     * @see      $_text
  584.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  585.     */
  586.     function setText($str)
  587.     {
  588.         $this->_text = $str;
  589.     }
  590.  
  591.  
  592.  
  593.  
  594.     /**
  595.     * Gets the unparsed text from the object
  596.     *
  597.     * @return   string          the text set in the object
  598.     * @access   public
  599.     * @see      setText()
  600.     * @see      $_text
  601.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  602.     */
  603.     function getText()
  604.     {
  605.         return $this->_text;
  606.     }
  607.  
  608.  
  609.  
  610.  
  611.     /**
  612.     * Gets the preparsed text from the object
  613.     *
  614.     * @return   string          the text set in the object
  615.     * @access   public
  616.     * @see      _preparse()
  617.     * @see      $_preparsed
  618.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  619.     */
  620.     function getPreparsed()
  621.     {
  622.         return $this->_preparsed;
  623.     }
  624.  
  625.  
  626.  
  627.  
  628.     /**
  629.     * Gets the parsed text from the object
  630.     *
  631.     * @return   string          the parsed text set in the object
  632.     * @access   public
  633.     * @see      parse()
  634.     * @see      $_parsed
  635.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  636.     */
  637.     function getParsed()
  638.     {
  639.         return $this->_parsed;
  640.     }
  641.  
  642.  
  643.  
  644.  
  645.     /**
  646.     * Parses the text set in the object
  647.     *
  648.     * @return   none
  649.     * @access   public
  650.     * @see      _preparse()
  651.     * @see      _buildTagArray()
  652.     * @see      _validateTagArray()
  653.     * @see      _buildParsedString()
  654.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  655.     */
  656.     function parse()
  657.     {
  658.         $this->_preparse();
  659.         $this->_buildTagArray();
  660.         $this->_validateTagArray();
  661.         $this->_buildParsedString();
  662.     }
  663.  
  664.  
  665.  
  666.  
  667.     /**
  668.     * Quick method to do setText(), parse() and getParsed at once
  669.     *
  670.     * @return   none
  671.     * @access   public
  672.     * @see      parse()
  673.     * @see      $_text
  674.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  675.     */
  676.     function qparse($str)
  677.     {
  678.         $this->_text = $str;
  679.         $this->parse();
  680.         return $this->_parsed;
  681.     }
  682.  
  683.  
  684.  
  685.  
  686.     /**
  687.     * Quick static method to do setText(), parse() and getParsed at once
  688.     *
  689.     * @return   none
  690.     * @access   public
  691.     * @see      parse()
  692.     * @see      $_text
  693.     * @author   Stijn de Reede  <sjr@gmx.co.uk>
  694.     */
  695.     function staticQparse($str)
  696.     {
  697.         $p = new HTML_BBCodeParser();
  698.         $str = $p->qparse($str);
  699.         unset($p);
  700.         return $str;
  701.     }
  702.  
  703.  
  704. }
  705.  
  706.  
  707. ?>
  708.